{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "98d3e0e6",
   "metadata": {},
   "source": [
    "## 实验4 第1题"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5a8c6e50",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入库\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "from sklearn.ensemble import AdaBoostClassifier\n",
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, precision_score, recall_score, \\\n",
    "    f1_score, classification_report\n",
    "from sklearn.tree import DecisionTreeClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e9de2106",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将数据转为数字,分割特征和标签\n",
    "def loadDataSet(filename):\n",
    "    # 获取每个样本的维度(包括标签)\n",
    "    dim = len(open(filename).readline().split('\\t'))\n",
    "    # 特征\n",
    "    data = []\n",
    "    # 标签\n",
    "    label = []\n",
    "    fr = open(filename)\n",
    "    for line in fr.readlines():  #一行行的读取\n",
    "        # 空列表,用来存放每一行数据\n",
    "        LineArr = []\n",
    "        # 以tab键划分，去除掉每个的空格\n",
    "        curline = line.strip().split('\\t')\n",
    "        for i in range(dim-1):\n",
    "            LineArr.append(float(curline[i]))\n",
    "        data.append(LineArr)\n",
    "        # 最后一列\n",
    "        label.append(float(curline[-1]))\n",
    "\n",
    "    # 返回特征和标签\n",
    "    return data,label"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "723d4d30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(299, 21)\n",
      "(67, 21)\n",
      "(299,)\n",
      "(67,)\n"
     ]
    }
   ],
   "source": [
    "# 加载数据集\n",
    "X_train,y_train = loadDataSet(\"./horse/horseColicTraining.txt\")\n",
    "X_test,y_test = loadDataSet(\"./horse/horseColicTest.txt\")\n",
    "print(np.shape(X_train)) # (299, 21)\n",
    "print(np.shape(X_test)) # (67, 21)\n",
    "print(np.shape(y_train)) # (299,)\n",
    "print(np.shape(y_test)) # (67,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "414dd832",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建弱分类器,决策树\n",
    "# 此处填入你的代码\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "# Create a weak classifier with max_depth=1\n",
    "weak_clf = DecisionTreeClassifier(max_depth=1)\n",
    "# Train the classifier on the training data\n",
    "weak_clf.fit(X_train, y_train)\n",
    "# Predict the labels on the test data\n",
    "y_pred = weak_clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c087b5e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# AdaBoost算法\n",
    "def My_Adaboost(X_train,Y_train, X_test,Y_test, M=20, weak_clf=DecisionTreeClassifier(max_depth = 1)):\n",
    "    n_train, n_test = len(X_train), len(X_test) # n_train=299,训练样本个数;n_test=67,测试样本个数\n",
    "    # 初始化权重w\n",
    "    w = np.ones(n_train) / n_train # ones生成全1数组 D = (w11,w12,...,w1N),w1i = 1 / N,i=1,2,..,N\n",
    "    pred_train, pred_test = [np.zeros(n_train), np.zeros(n_test)] # 生成空列表\n",
    "    for i in range(M):    # M为基学习器个数\n",
    "        # 使用特定权重拟合分类器\n",
    "        weak_clf.fit(X_train, Y_train, sample_weight = w) # 用训练器数据拟合分类器模型\n",
    "        pred_train_i = weak_clf.predict(X_train) # 预测(-1/1)\n",
    "        pred_test_i = weak_clf.predict(X_test)\n",
    "\n",
    "        # miss相当于I(Gm(x)!=y),I为指示函数;pred_train_i相当于Gm(x)\n",
    "        miss = [int(x) for x in (pred_train_i != Y_train)] # pred_train_i != Y_train:x=0;pred_train_i == Y_train:x=1\n",
    "        print(\"weak_clf_%02d train acc: %.4f\"% (i + 1, 1 - sum(miss) / n_train))\n",
    "        # 基学习器Gm(x)\n",
    "        # err_m = w * I(Gm(x)!=y),I为指示函数,err_m相当于分类误差率em\n",
    "        # 错分率=分类错误样本权之和（经过归一化）\n",
    "        err_m = np.dot(w, miss) # 矩阵乘积\n",
    "        # Gm(x)的系数:Alpha_m,即最终集成使用的的基学习器的权重\n",
    "        alpha_m = 0.5 * np.log((1 - err_m) / float(err_m))\n",
    "        # 更新训练样本的权重,if x==1返回x,else 返回-1\n",
    "        miss2 = [x if x==1 else -1 for x in miss] # miss2 = -1 * y_i * G(x_i) = 1 / -1\n",
    "        w = np.multiply(w, np.exp([float(x) * alpha_m for x in miss2])) #multiply()函数对应元素相乘\n",
    "        w = w / sum(w)\n",
    "\n",
    "        # 添加到prediction\n",
    "        pred_train_i = [1 if x == 1 else -1 for x in pred_train_i] # 返回-1/1\n",
    "        pred_test_i = [1 if x == 1 else -1 for x in pred_test_i]\n",
    "        # 组合分类器,构建最终的分类器线性组合f(x),pred_train = f(x)\n",
    "        pred_train = pred_train + np.multiply(alpha_m, pred_train_i)\n",
    "        pred_test = pred_test + np.multiply(alpha_m, pred_test_i)\n",
    "\n",
    "    # 当x>0，sign(x)=1;当x=0，sign(x)=0; 当x<0， sign(x)=-1\n",
    "    pred_train = (pred_train > 0) * 1 # * 1 是为了将True/False变成1/0\n",
    "    pred_test = (pred_test > 0) * 1\n",
    "    # 训练精度\n",
    "    print(\"Accuracy of train is\",sum(pred_train == y_train) / n_train)\n",
    "    # 测试精度\n",
    "    print(\"Accuracy of test is\",sum(pred_test == y_test) / n_test)\n",
    "\n",
    "    return  pred_train,pred_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "dd8477a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "weak_clf_01 train acc: 0.7157\n",
      "weak_clf_02 train acc: 0.7157\n",
      "weak_clf_03 train acc: 0.4047\n",
      "weak_clf_04 train acc: 0.6187\n",
      "weak_clf_05 train acc: 0.6421\n",
      "weak_clf_06 train acc: 0.5953\n",
      "weak_clf_07 train acc: 0.6254\n",
      "weak_clf_08 train acc: 0.4047\n",
      "weak_clf_09 train acc: 0.6789\n",
      "weak_clf_10 train acc: 0.4749\n",
      "weak_clf_11 train acc: 0.6187\n",
      "weak_clf_12 train acc: 0.5418\n",
      "weak_clf_13 train acc: 0.4047\n",
      "weak_clf_14 train acc: 0.6221\n",
      "weak_clf_15 train acc: 0.4047\n",
      "weak_clf_16 train acc: 0.6087\n",
      "weak_clf_17 train acc: 0.4916\n",
      "weak_clf_18 train acc: 0.6355\n",
      "weak_clf_19 train acc: 0.4047\n",
      "weak_clf_20 train acc: 0.6087\n",
      "Accuracy of train is 0.7759197324414716\n",
      "Accuracy of test is 0.7761194029850746\n"
     ]
    }
   ],
   "source": [
    "# 预测测试集标签\n",
    "y_train_pred,y_test_pred =My_Adaboost(X_train, y_train, X_test, y_test, M=20, weak_clf=weak_clf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "3b0a4ed9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Confusion matrix of Label is \n",
      " [[13  7]\n",
      " [ 8 39]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 混淆矩阵格式如下：\n",
    "# #[TN FP]\n",
    "# #[FN TP]\n",
    "#生成混淆矩阵，此处填入你的代码。（3）\n",
    "from sklearn.metrics import confusion_matrix\n",
    "# Generate a confusion matrix\n",
    "cm = confusion_matrix(y_test, y_test_pred)\n",
    "print(\"Confusion matrix of Label is \\n\",cm)\n",
    "# confusion_matrix(混淆矩阵), display_labels(标签名称列表)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['0','1'])\n",
    "# 画出混淆矩阵\n",
    "disp.plot()\n",
    "plt.title(\"Confusion matrix\")\n",
    "# 保存\n",
    "plt.savefig(\"Confusion_matrix\")\n",
    "# 显示\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d6bd0acb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rate of death is  0.31343283582089554\n"
     ]
    }
   ],
   "source": [
    "# 计算死亡率#,标签1表示存活,0表示死亡\n",
    "print(\"Rate of death is \",np.sum(y_test_pred == 0) / len(y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "91b3bbd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Precision of Label is 0.8478260869565217\n"
     ]
    }
   ],
   "source": [
    "# 精确度 P = TP / (TP + FP)\n",
    "#输出精确度，此处填入你的代码。（4）\n",
    "# Calculate precision\n",
    "precision = precision_score(y_test, y_test_pred)\n",
    "# Print precision\n",
    "print(\"Precision of Label is\", precision)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1bcf10b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall of Label is 0.8297872340425532\n"
     ]
    }
   ],
   "source": [
    "# 召回率R = TP / (TP + FN)\n",
    "print(\"Recall of Label is\",recall_score(y_test,y_test_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "31abf842",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F1 of Label is 0.8387096774193549\n"
     ]
    }
   ],
   "source": [
    "# F1度量 F1 = (2 x P x R) / (P + R)\n",
    "print(\"F1 of Label is\",f1_score(y_test,y_test_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "eb6eda0a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.61      0.70      0.65        20\n",
      "         1.0       0.86      0.81      0.84        47\n",
      "\n",
      "    accuracy                           0.78        67\n",
      "   macro avg       0.74      0.75      0.74        67\n",
      "weighted avg       0.79      0.78      0.78        67\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ist/miniconda3/envs/pytorch/lib/python3.9/site-packages/sklearn/ensemble/_base.py:166: FutureWarning: `base_estimator` was renamed to `estimator` in version 1.2 and will be removed in 1.4.\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# 与sklearn的AdaBoostClassifier的结果比较\n",
    "# 此处填入你的代码。（5）\n",
    "model = AdaBoostClassifier(n_estimators=20, base_estimator=DecisionTreeClassifier(max_depth=1))\n",
    "# 拟合\n",
    "model.fit(X_train, y_train)\n",
    "# 预测\n",
    "y_pred = model.predict(X_test)\n",
    "# 输出精度报告\n",
    "print(classification_report(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "8a4d513b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 绘制P-R曲线\n",
    "def PR_curve(y,pred):\n",
    "    # pos为真实的正例标签个数\n",
    "    pos = np.sum(y == 1)\n",
    "    # 从大到小排序\n",
    "    pred_sort = np.sort(pred)[::-1]\n",
    "    # 从大到小排序的索引\n",
    "    index = np.argsort(pred)[::-1]\n",
    "    y_sort = y[index]\n",
    "\n",
    "    # Precision\n",
    "    Pre = []\n",
    "    # Recall\n",
    "    Rec = []\n",
    "    for i, item in enumerate(pred_sort):\n",
    "        if i == 0:\n",
    "            # 因为计算precision的时候分母要用到i，当i为0时会出错，所以单独列出\n",
    "            Pre.append(0)\n",
    "            Rec.append(0)\n",
    "        else:\n",
    "            # Precision = TP / TP + FP,i = TP + FP,预测为1的个数\n",
    "            Pre.append(np.sum((y_sort[:i] == 1)) /i)\n",
    "            # Recall = TP / TP + FN\n",
    "            Rec.append(np.sum((y_sort[:i] == 1)) / pos)\n",
    "\n",
    "    # 画图\n",
    "    # 横坐标Rec,纵坐标pre\n",
    "    plt.plot(Rec, Pre, 'r')\n",
    "    plt.title('Precision/Recall Curve')\n",
    "    plt.xlim([-0.01, 1.01])\n",
    "    plt.ylim([-0.01, 01.01])\n",
    "    plt.ylabel('Precision')\n",
    "    plt.xlabel('Recall')\n",
    "    # 保存\n",
    "    plt.savefig(\"P_R_Curve\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "1290f051",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7fcc4d082be0>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制P-R曲线\n",
    "# PR_curve(np.array(y_test),y_test_pred)\n",
    "# 预测\n",
    "\n",
    "# 绘制PR曲线  这个曲线绘图不好\n",
    "from sklearn.metrics import precision_recall_curve\n",
    "\n",
    "precision, recall, threshold = precision_recall_curve(y_test, y_test_pred,pos_label=1)\n",
    "fig = plt.figure()\n",
    "plt.plot(precision, recall, label='Horse Colic')\n",
    "\n",
    "plt.xlabel('Recall')\n",
    "plt.ylabel('Precision')\n",
    "plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c2a23e0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import precision_recall_curve, average_precision_score\n",
    "# Calculate precision and recall\n",
    "precision, recall, threshold = precision_recall_curve(y_test, y_test_pred,pos_label=1)\n",
    "# Calculate average precision score\n",
    "ap = average_precision_score(y_test, y_test_pred)\n",
    "# Create precision recall curve\n",
    "fig, ax = plt.subplots()\n",
    "ax.plot(recall, precision, color='blue', label='Horse Colic')\n",
    "# Add title and axis labels\n",
    "ax.set_title('Precision-Recall Curve')\n",
    "ax.set_ylabel('Precision')\n",
    "ax.set_xlabel('Recall')\n",
    "# Add legend\n",
    "ax.legend()\n",
    "# Adjust x and y limits\n",
    "ax.set_xlim([0, 1])\n",
    "ax.set_ylim([0, 1])\n",
    "# Add reference line or point\n",
    "ax.plot([0, 1], [ap, ap], linestyle='--', color='red', label='Average Precision')\n",
    "ax.scatter(recall[np.argmax(precision + recall)], precision[np.argmax(precision + recall)], color='green', label='Best F1')\n",
    "# Display plot\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python [conda env:pytorch]",
   "language": "python",
   "name": "conda-env-pytorch-py"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
